home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 10 / AACD 10.iso / AACD / Games / MAME / src / sound / 2610intf.c < prev    next >
C/C++ Source or Header  |  2000-04-23  |  8KB  |  299 lines
  1. /***************************************************************************
  2.  
  3.   2610intf.c
  4.  
  5.   The YM2610 emulator supports up to 2 chips.
  6.   Each chip has the following connections:
  7.   - Status Read / Control Write A
  8.   - Port Read / Data Write A
  9.   - Control Write B
  10.   - Data Write B
  11.  
  12. ***************************************************************************/
  13.  
  14. #include "driver.h"
  15. #include "ay8910.h"
  16. #include "fm.h"
  17.  
  18. #if BUILD_YM2610
  19.  
  20. /* use FM.C with stream system */
  21.  
  22. static int stream[MAX_2610];
  23.  
  24. /* Global Interface holder */
  25. static const struct YM2610interface *intf;
  26.  
  27. static void *Timer[MAX_2610][2];
  28.  
  29. /*------------------------- TM2610 -------------------------------*/
  30. /* IRQ Handler */
  31. static void IRQHandler(int n,int irq)
  32. {
  33.     if(intf->handler[n]) intf->handler[n](irq);
  34. }
  35.  
  36. /* Timer overflow callback from timer.c */
  37. static void timer_callback_2610(int param)
  38. {
  39.     int n=param&0x7f;
  40.     int c=param>>7;
  41.  
  42. //    logerror("2610 TimerOver %d\n",c);
  43.     Timer[n][c] = 0;
  44.     YM2610TimerOver(n,c);
  45. }
  46.  
  47. /* TimerHandler from fm.c */
  48. static void TimerHandler(int n,int c,int count,double stepTime)
  49. {
  50.     if( count == 0 )
  51.     {    /* Reset FM Timer */
  52.         if( Timer[n][c] )
  53.         {
  54. //            logerror("2610 TimerReset %d\n",c);
  55.              timer_remove (Timer[n][c]);
  56.             Timer[n][c] = 0;
  57.         }
  58.     }
  59.     else
  60.     {    /* Start FM Timer */
  61.         double timeSec = (double)count * stepTime;
  62.  
  63.         if( Timer[n][c] == 0 )
  64.         {
  65.             Timer[n][c] = timer_set (timeSec , (c<<7)|n, timer_callback_2610 );
  66.         }
  67.     }
  68. }
  69.  
  70. static void FMTimerInit( void )
  71. {
  72.     int i;
  73.  
  74.     for( i = 0 ; i < MAX_2610 ; i++ )
  75.         Timer[i][0] = Timer[i][1] = 0;
  76. }
  77.  
  78. /* update request from fm.c */
  79. void YM2610UpdateRequest(int chip)
  80. {
  81.     stream_update(stream[chip],100);
  82. }
  83.  
  84. int YM2610_sh_start(const struct MachineSound *msound)
  85. {
  86.     int i,j;
  87.     int rate = Machine->sample_rate;
  88.     char buf[YM2610_NUMBUF][40];
  89.     const char *name[YM2610_NUMBUF];
  90.     int mixed_vol,vol[YM2610_NUMBUF];
  91.     void *pcmbufa[YM2610_NUMBUF],*pcmbufb[YM2610_NUMBUF];
  92.     int  pcmsizea[YM2610_NUMBUF],pcmsizeb[YM2610_NUMBUF];
  93.  
  94.     intf = msound->sound_interface;
  95.     if( intf->num > MAX_2610 ) return 1;
  96.  
  97.     if (AY8910_sh_start(msound)) return 1;
  98.  
  99.     /* Timer Handler set */
  100.     FMTimerInit();
  101.  
  102.     /* stream system initialize */
  103.     for (i = 0;i < intf->num;i++)
  104.     {
  105.         /* stream setup */
  106.         mixed_vol = intf->volumeFM[i];
  107.         /* stream setup */
  108.         for (j = 0 ; j < YM2610_NUMBUF ; j++)
  109.         {
  110.             name[j]=buf[j];
  111.             vol[j] = mixed_vol & 0xffff;
  112.             mixed_vol>>=16;
  113.             sprintf(buf[j],"%s #%d Ch%d",sound_name(msound),i,j+1);
  114.         }
  115.         stream[i] = stream_init_multi(YM2610_NUMBUF,name,vol,rate,i,YM2610UpdateOne);
  116.         /* setup adpcm buffers */
  117.         pcmbufa[i]  = (void *)(memory_region(intf->pcmroma[i]));
  118.         pcmsizea[i] = memory_region_length(intf->pcmroma[i]);
  119.         pcmbufb[i]  = (void *)(memory_region(intf->pcmromb[i]));
  120.         pcmsizeb[i] = memory_region_length(intf->pcmromb[i]);
  121.     }
  122.  
  123.     /**** initialize YM2610 ****/
  124.     if (YM2610Init(intf->num,intf->baseclock,rate,
  125.                    pcmbufa,pcmsizea,pcmbufb,pcmsizeb,
  126.                    TimerHandler,IRQHandler) == 0)
  127.         return 0;
  128.  
  129.     /* error */
  130.     return 1;
  131. }
  132.  
  133. #if BUILD_YM2610B
  134. int YM2610B_sh_start(const struct MachineSound *msound)
  135. {
  136.     int i,j;
  137.     int rate = Machine->sample_rate;
  138.     char buf[YM2610_NUMBUF][40];
  139.     const char *name[YM2610_NUMBUF];
  140.     int mixed_vol,vol[YM2610_NUMBUF];
  141.     void *pcmbufa[YM2610_NUMBUF],*pcmbufb[YM2610_NUMBUF];
  142.     int  pcmsizea[YM2610_NUMBUF],pcmsizeb[YM2610_NUMBUF];
  143.  
  144.     intf = msound->sound_interface;
  145.     if( intf->num > MAX_2610 ) return 1;
  146.  
  147.     if (AY8910_sh_start(msound)) return 1;
  148.  
  149.     /* Timer Handler set */
  150.     FMTimerInit();
  151.  
  152.     /* stream system initialize */
  153.     for (i = 0;i < intf->num;i++)
  154.     {
  155.         /* stream setup */
  156.         mixed_vol = intf->volumeFM[i];
  157.         /* stream setup */
  158.         for (j = 0 ; j < YM2610_NUMBUF ; j++)
  159.         {
  160.             name[j]=buf[j];
  161.             vol[j] = mixed_vol & 0xffff;
  162.             mixed_vol>>=16;
  163.             sprintf(buf[j],"%s #%d Ch%d",sound_name(msound),i,j+1);
  164.         }
  165.         stream[i] = stream_init_multi(YM2610_NUMBUF,name,vol,rate,i,YM2610BUpdateOne);
  166.         /* setup adpcm buffers */
  167.         pcmbufa[i]  = (void *)(memory_region(intf->pcmroma[i]));
  168.         pcmsizea[i] = memory_region_length(intf->pcmroma[i]);
  169.         pcmbufb[i]  = (void *)(memory_region(intf->pcmromb[i]));
  170.         pcmsizeb[i] = memory_region_length(intf->pcmromb[i]);
  171.     }
  172.  
  173.     /**** initialize YM2610 ****/
  174.     if (YM2610Init(intf->num,intf->baseclock,rate,
  175.                    pcmbufa,pcmsizea,pcmbufb,pcmsizeb,
  176.                    TimerHandler,IRQHandler) == 0)
  177.         return 0;
  178.  
  179.     /* error */
  180.     return 1;
  181. }
  182. #endif
  183.  
  184. /************************************************/
  185. /* Sound Hardware Stop                            */
  186. /************************************************/
  187. void YM2610_sh_stop(void)
  188. {
  189.     YM2610Shutdown();
  190. }
  191.  
  192. /* reset */
  193. void YM2610_sh_reset(void)
  194. {
  195.     int i;
  196.  
  197.     for (i = 0;i < intf->num;i++)
  198.         YM2610ResetChip(i);
  199. }
  200.  
  201. /************************************************/
  202. /* Status Read for YM2610 - Chip 0                */
  203. /************************************************/
  204. READ_HANDLER( YM2610_status_port_0_A_r )
  205. {
  206. //logerror("PC %04x: 2610 S0A=%02X\n",cpu_get_pc(),YM2610Read(0,0));
  207.     return YM2610Read(0,0);
  208. }
  209.  
  210. READ_HANDLER( YM2610_status_port_0_B_r )
  211. {
  212. //logerror("PC %04x: 2610 S0B=%02X\n",cpu_get_pc(),YM2610Read(0,2));
  213.     return YM2610Read(0,2);
  214. }
  215.  
  216. /************************************************/
  217. /* Status Read for YM2610 - Chip 1                */
  218. /************************************************/
  219. READ_HANDLER( YM2610_status_port_1_A_r ) {
  220.     return YM2610Read(1,0);
  221. }
  222.  
  223. READ_HANDLER( YM2610_status_port_1_B_r ) {
  224.     return YM2610Read(1,2);
  225. }
  226.  
  227. /************************************************/
  228. /* Port Read for YM2610 - Chip 0                */
  229. /************************************************/
  230. READ_HANDLER( YM2610_read_port_0_r ){
  231.     return YM2610Read(0,1);
  232. }
  233.  
  234. /************************************************/
  235. /* Port Read for YM2610 - Chip 1                */
  236. /************************************************/
  237. READ_HANDLER( YM2610_read_port_1_r ){
  238.     return YM2610Read(1,1);
  239. }
  240.  
  241. /************************************************/
  242. /* Control Write for YM2610 - Chip 0            */
  243. /* Consists of 2 addresses                        */
  244. /************************************************/
  245. WRITE_HANDLER( YM2610_control_port_0_A_w )
  246. {
  247. //logerror("PC %04x: 2610 Reg A %02X",cpu_get_pc(),data);
  248.     YM2610Write(0,0,data);
  249. }
  250.  
  251. WRITE_HANDLER( YM2610_control_port_0_B_w )
  252. {
  253. //logerror("PC %04x: 2610 Reg B %02X",cpu_get_pc(),data);
  254.     YM2610Write(0,2,data);
  255. }
  256.  
  257. /************************************************/
  258. /* Control Write for YM2610 - Chip 1            */
  259. /* Consists of 2 addresses                        */
  260. /************************************************/
  261. WRITE_HANDLER( YM2610_control_port_1_A_w ){
  262.     YM2610Write(1,0,data);
  263. }
  264.  
  265. WRITE_HANDLER( YM2610_control_port_1_B_w ){
  266.     YM2610Write(1,2,data);
  267. }
  268.  
  269. /************************************************/
  270. /* Data Write for YM2610 - Chip 0                */
  271. /* Consists of 2 addresses                        */
  272. /************************************************/
  273. WRITE_HANDLER( YM2610_data_port_0_A_w )
  274. {
  275. //logerror(" =%02X\n",data);
  276.     YM2610Write(0,1,data);
  277. }
  278.  
  279. WRITE_HANDLER( YM2610_data_port_0_B_w )
  280. {
  281. //logerror(" =%02X\n",data);
  282.     YM2610Write(0,3,data);
  283. }
  284.  
  285. /************************************************/
  286. /* Data Write for YM2610 - Chip 1                */
  287. /* Consists of 2 addresses                        */
  288. /************************************************/
  289. WRITE_HANDLER( YM2610_data_port_1_A_w ){
  290.     YM2610Write(1,1,data);
  291. }
  292. WRITE_HANDLER( YM2610_data_port_1_B_w ){
  293.     YM2610Write(1,3,data);
  294. }
  295.  
  296. /**************** end of file ****************/
  297.  
  298. #endif
  299.